﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Media;
using System.Collections.ObjectModel;
using System.Data;
using System.Windows.Media.Imaging;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Controls;
using System.Globalization;
using produccion.modelo;
using produccion.AccesoDatos;
using produccion.clases;
using produccion.modulos;
using System.Windows.Input;
using System.Collections.Specialized;
using produccion.forms;

namespace produccion.vistamodelo
{
    class VMGarantiasServiciosyReconocidos : ViewModelBase, IDataErrorInfo
    {
        #region FJRF - VARIABLES GENERICAS DE TODO EL FORMULARIO
        DataTable DtImprimir;//FJRF - Usamos este DataTable para imprimir
        DataTable DtConsulta;//FJRF - Usamos este DataTable para consultas temporales
        DataSet DsImprimir;//FJRF - Usamos este dataset para la impresion de consultas
        String StrConsulta;//FJRF - Para hacer consultas temporales
        String StrRutaReporteCrystalReport = @"reportes\";//FJRF - Esta es la ruta de los reportes de crystal reports
        #endregion

        #region Campos
        private CLSMAECLIP _cliente = new CLSMAECLIP();
        private CLSMAEDANP _daños = new CLSMAEDANP();
        private CLSMOTREPP _reparaciones = new CLSMOTREPP();
        private CLSTABPIE _piezas = new CLSTABPIE();
        private CLSMAEEMPP _empleados = new CLSMAEEMPP();
        private CLSTABCAU _causas = new CLSTABCAU();
        private CLSTABSOL _soluciones = new CLSTABSOL();
        private CLSMAEREF _ref = new CLSMAEREF();
        private CLSMAECOL _col = new CLSMAECOL();
        private CLSMAEPRO _prod = new CLSMAEPRO();
        private MDOgeneral mod = new MDOgeneral();
        private CLSENCORDP _ordenes = new CLSENCORDP();
        private MGarantiasServiciosyReconocidos _gar = new MGarantiasServiciosyReconocidos();
        private int _numBusqueda;
        private int _numBusquedaSol;
        private ProcesoProduccionRepositorio _repositorio = new ProcesoProduccionRepositorio();
        #endregion

        #region Constructor
            public VMGarantiasServiciosyReconocidos()
            {
                try
                {
                    lisclientes = _cliente.listaClienteGarantias();
                    lispiezas = _piezas.listarPiezas();
                    lisresponsables = _empleados.listaEmpleados();
                    liscausas = _causas.listarCausas();
                    lissoluciones = _soluciones.listarSoluciones();
                    lisdesiciones = _empleados.listaEmpleados();
                    cargarClientes();
                    cargarReferencias();
                    dtDocumento = new DataTable();

                    consultarReparaciones("ZZZ");
                    if (MDOgeneral.conexion == null || MDOgeneral.conexion.State == ConnectionState.Closed)
                    {
                        MDOgeneral.conectar();
                    }
                    strTituloVentana = "Procesar Garantias Servicios y Reconocidos - Usuario: " + MDOgeneral.usuario + " - [FRMProcesarGarantiasServiciosyReconocidos]";
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }
        #endregion

        #region Propiedades
        
        private string _strTituloVentana;
        public string strTituloVentana
        {
            get { return _strTituloVentana; }
            set { _strTituloVentana = value; base.OnPropertyChanged("strTituloVentana"); }
        }

        private List<CLSMAECLIP> _lisclientes = new List<CLSMAECLIP>();
        public List<CLSMAECLIP> lisclientes
        {
            get { return _lisclientes; }
            set { _lisclientes = value; base.OnPropertyChanged("lisclientes"); }
        }

        private CLSMAECLIP _selcliente = new CLSMAECLIP();
        public CLSMAECLIP selcliente
        {
            get { return _selcliente; }
            set 
            { 
                _selcliente = value; 
                base.OnPropertyChanged("selcliente");
                if (selcliente != null)
                {
                    if (selcliente.CODCLI_CLI != null)
                        consultarReparaciones(selcliente.CODCLI_CLI);
                }
            }
        }

        private List<CLSTABPIE> _lispiezas = new List<CLSTABPIE>();
        public List<CLSTABPIE> lispiezas
        {
            get { return _lispiezas; }
            set { _lispiezas = value; base.OnPropertyChanged("lispiezas"); }
        }

        private CLSTABPIE _selpieza = new CLSTABPIE();
        public CLSTABPIE selpieza
        {
            get { return _selpieza; }
            set { _selpieza = value; base.OnPropertyChanged("selpieza"); }
        }

        private List<CLSMAEEMPP> _lisresponsables = new List<CLSMAEEMPP>();
        public List<CLSMAEEMPP> lisresponsables
        {
            get { return _lisresponsables; }
            set { _lisresponsables = value; base.OnPropertyChanged("lisresponsables"); }
        }

        private CLSMAEEMPP _selresponsable = new CLSMAEEMPP();
        public CLSMAEEMPP selresponsable
        {
            get { return _selresponsable; }
            set { _selresponsable = value; base.OnPropertyChanged("selresponsable"); }
        }

        private List<CLSTABCAU> _liscausas = new List<CLSTABCAU>();
        public List<CLSTABCAU> liscausas
        {
            get { return _liscausas; }
            set { _liscausas = value; base.OnPropertyChanged("liscausas"); }
        }

        private CLSTABCAU _selcausa = new CLSTABCAU();
        public CLSTABCAU selcausa
        {
            get { return _selcausa; }
            set { _selcausa = value; base.OnPropertyChanged("selcausa"); }
        }

        private List<CLSTABSOL> _lissoluciones = new List<CLSTABSOL>();
        public List<CLSTABSOL> lissoluciones
        {
            get { return _lissoluciones; }
            set { _lissoluciones = value; base.OnPropertyChanged("lissoluciones"); }
        }

        private CLSTABSOL _selsolucion = new CLSTABSOL();
        public CLSTABSOL selsolucion
        {
            get { return _selsolucion; }
            set { _selsolucion = value; base.OnPropertyChanged("selsolucion"); }
        }

        private List<CLSMAEEMPP> _lisdesiciones = new List<CLSMAEEMPP>();
        public List<CLSMAEEMPP> lisdesiciones
        {
            get { return _lisdesiciones; }
            set { _lisdesiciones = value; base.OnPropertyChanged("lisdesiciones"); }
        }

        private CLSMAEEMPP _seldesicion = new CLSMAEEMPP();
        public CLSMAEEMPP seldesicion
        {
            get { return _seldesicion; }
            set { _seldesicion = value; base.OnPropertyChanged("seldesicion"); }
        }

        private string _strTipoFiltro = "T";
        public string strTipoFiltro
        {
            get { return _strTipoFiltro; }
            set 
            { 
                _strTipoFiltro = value; 
                base.OnPropertyChanged("strTipoFiltro");
                if (strTipoFiltro != null)
                {
                    if (selcliente.CODCLI_CLI != null)
                        consultarReparaciones(selcliente.CODCLI_CLI);
                    else
                        consultarReparaciones("ZZZ");
                }
            }
        }

        private string _strNroDocumento;
        public string strNroDocumento
        {
            get { return _strNroDocumento; }
            set 
            { 
                _strNroDocumento = value; 
                base.OnPropertyChanged("strNroDocumento");
                if (strNroDocumento != null)
                {
                    if (strTipoFiltro != null)
                    {
                        if (selcliente.CODCLI_CLI != null)
                            consultarReparaciones(selcliente.CODCLI_CLI);
                        else
                            consultarReparaciones("ZZZ");
                    }
                }
            }
        }

        private string _strCodigoCliente;
        public string strCodigoCliente
        {
            get { return _strCodigoCliente; }
            set { _strCodigoCliente = value; base.OnPropertyChanged("strCodigoCliente"); }
        }

        private string _strNombreCliente;
        public string strNombreCliente
        {
            get { return _strNombreCliente; }
            set { _strNombreCliente = value; base.OnPropertyChanged("strNombreCliente"); }
        }

        private string _strTipoMov;
        public string strTipoMov
        {
            get { return _strTipoMov; }
            set {  _strTipoMov = value; base.OnPropertyChanged("strTipoMov"); }
        }

        private string _strDocumento;
        public string strDocumento
        {
            get { return _strDocumento; }
            set { _strDocumento = value; base.OnPropertyChanged("strDocumento"); }
        }

        private string _strReparacion;
        public string strReparacion
        {
            get { return _strReparacion; }
            set { _strReparacion = value; base.OnPropertyChanged("strReparacion"); }
        }

        private string _strControl;
        public string strControl
        {
            get { return _strControl; }
            set { _strControl = value; base.OnPropertyChanged("strControl"); }
        }

        private string _strReferencia ;
        public string strReferencia
        {
            get { return _strReferencia; }
            set { _strReferencia = value; base.OnPropertyChanged("strReferencia"); }
        }

        private string _strNombreReferencia;
        public string strNombreReferencia
        {
            get { return _strNombreReferencia; }
            set { _strNombreReferencia = value; base.OnPropertyChanged("strNombreReferencia"); }
        }

        private string _strColor;
        public string strColor
        {
            get { return _strColor; }
            set { _strColor = value; base.OnPropertyChanged("strColor"); }
        }

        private string _strNombreColor;
        public string strNombreColor
        {
            get { return _strNombreColor; }
            set { _strNombreColor = value; base.OnPropertyChanged("strNombreColor"); }
        }

        private string _strTalla;
        public string strTalla
        {
            get { return _strTalla; }
            set { _strTalla = value; base.OnPropertyChanged("strTalla"); }
        }

        private string _strMotivo1;
        public string strMotivo1
        {
            get { return _strMotivo1; }
            set { _strMotivo1 = value; base.OnPropertyChanged("strMotivo1"); }
        }

        private string _strMotivo2;
        public string strMotivo2
        {
            get { return _strMotivo2; }
            set { _strMotivo2 = value; base.OnPropertyChanged("strMotivo2"); }
        }

        private string _strMotivo3;
        public string strMotivo3
        {
            get { return _strMotivo3; }
            set { _strMotivo3 = value; base.OnPropertyChanged("strMotivo3"); }
        }

        private string _strMotivo4;
        public string strMotivo4
        {
            get { return _strMotivo4; }
            set { _strMotivo4 = value; base.OnPropertyChanged("strMotivo4"); }
        }

        private string _strMotivo5;
        public string strMotivo5
        {
            get { return _strMotivo5; }
            set { _strMotivo5 = value; base.OnPropertyChanged("strMotivo5"); }
        }

        private string _strObservacion;
        public string strObservacion
        {
            get { return _strObservacion; }
            set { _strObservacion = value; base.OnPropertyChanged("strObservacion"); }
        }

        private string _strDaño1;
        public string strDaño1
        {
            get { return _strDaño1; }
            set 
            { 
                _strDaño1 = value; 
                base.OnPropertyChanged("strDaño1");
                if (strDaño1 != null)
                {
                    if (strDaño1.Length == 3)
                    {
                        _daños.CODDAN_MDN = strDaño1;
                        _daños.Consultar();
                        if (_daños.EXISTE)
                        {
                            strDaño1 = _daños.NOMDAN_MDN;
                            strCodigoDaño1 = _daños.CODDAN_MDN;
                        }
                    }
                }
            }
        }

        private string _strDaño2;
        public string strDaño2
        {
            get { return _strDaño2; }
            set 
            { 
                _strDaño2 = value; 
                base.OnPropertyChanged("strDaño2");
                if (strDaño2 != null)
                {
                    if (strDaño2.Length == 3)
                    {
                        _daños.CODDAN_MDN = strDaño2;
                        _daños.Consultar();
                        if (_daños.EXISTE)
                        {
                            strDaño2 = _daños.NOMDAN_MDN;
                            strCodigoDaño2 = _daños.CODDAN_MDN;
                        }
                    }
                }
            }
        }

        private string _strDaño3;
        public string strDaño3
        {
            get { return _strDaño3; }
            set 
            { 
                _strDaño3 = value; 
                base.OnPropertyChanged("strDaño3");
                if (strDaño3 != null)
                {
                    if (strDaño3.Length == 3)
                    {
                        _daños.CODDAN_MDN = strDaño3;
                        _daños.Consultar();
                        if (_daños.EXISTE)
                        {
                            strDaño3 = _daños.NOMDAN_MDN;
                            strCodigoDaño3 = _daños.CODDAN_MDN;
                        }
                    }
                }
            }
        }

        private string _strDaño4;
        public string strDaño4
        {
            get { return _strDaño4; }
            set 
            { 
                _strDaño4 = value; 
                base.OnPropertyChanged("strDaño4");
                if (strDaño4 != null)
                {
                    if (strDaño4.Length == 3)
                    {
                        _daños.CODDAN_MDN = strDaño4;
                        _daños.Consultar();
                        if (_daños.EXISTE)
                        {
                            strDaño4 = _daños.NOMDAN_MDN;
                            strCodigoDaño4 = _daños.CODDAN_MDN;
                        }
                    }
                }
            }
        }

        private string _strDaño5;
        public string strDaño5
        {
            get { return _strDaño5; }
            set 
            { 
                _strDaño5 = value; 
                base.OnPropertyChanged("strDaño5");
                if (strDaño5 != null)
                {
                    if (strDaño5.Length == 3)
                    {
                        _daños.CODDAN_MDN = strDaño5;
                        _daños.Consultar();
                        if (_daños.EXISTE)
                        {
                            strDaño5 = _daños.NOMDAN_MDN;
                            strCodigoDaño5 = _daños.CODDAN_MDN;
                        }
                    }
                }
            }
        }

        private string _strCodigoDaño1;
        public string strCodigoDaño1
        {
            get { return _strCodigoDaño1; }
            set { _strCodigoDaño1 = value; base.OnPropertyChanged("strCodigoDaño1"); }
        }

        private string _strCodigoDaño2;
        public string strCodigoDaño2
        {
            get { return _strCodigoDaño2; }
            set { _strCodigoDaño2 = value; base.OnPropertyChanged("strCodigoDaño2"); }
        }

        private string _strCodigoDaño3;
        public string strCodigoDaño3
        {
            get { return _strCodigoDaño3; }
            set { _strCodigoDaño3 = value; base.OnPropertyChanged("strCodigoDaño3"); }
        }

        private string _strCodigoDaño4;
        public string strCodigoDaño4
        {
            get { return _strCodigoDaño4; }
            set { _strCodigoDaño4 = value; base.OnPropertyChanged("strCodigoDaño4"); }
        }

        private string _strCodigoDaño5;
        public string strCodigoDaño5
        {
            get { return _strCodigoDaño5; }
            set { _strCodigoDaño5 = value; base.OnPropertyChanged("strCodigoDaño5"); }
        }

        private string _strSolucion1;
        public string strSolucion1
        {
            get { return _strSolucion1; }
            set 
            { 
                _strSolucion1 = value; 
                base.OnPropertyChanged("strSolucion1");
                if (strSolucion1 != null)
                {
                    if (strSolucion1.Length == 3)
                    {
                        _reparaciones.CODMOT_MRP = strSolucion1;
                        _reparaciones.Consultar();
                        if (_reparaciones.EXISTE)
                        {
                            strSolucion1 = _reparaciones.NOMMOT_MRP;
                            strCodigoSolucion1 = _reparaciones.CODMOT_MRP;
                        }
                    }
                }
            }
        }

        private string _strSolucion2;
        public string strSolucion2
        {
            get { return _strSolucion2; }
            set 
            { 
                _strSolucion2 = value; 
                base.OnPropertyChanged("strSolucion2");
                if (strSolucion2 != null)
                {
                    if (strSolucion2.Length == 3)
                    {
                        _reparaciones.CODMOT_MRP = strSolucion2;
                        _reparaciones.Consultar();
                        if (_reparaciones.EXISTE)
                        {
                            strSolucion2 = _reparaciones.NOMMOT_MRP;
                            strCodigoSolucion2 = _reparaciones.CODMOT_MRP;
                        }
                    }
                }
            }
        }

        private string _strSolucion3;
        public string strSolucion3
        {
            get { return _strSolucion3; }
            set 
            { 
                _strSolucion3 = value; 
                base.OnPropertyChanged("strSolucion3");
                if (strSolucion3 != null)
                {
                    if (strSolucion3.Length == 3)
                    {
                        _reparaciones.CODMOT_MRP = strSolucion3;
                        _reparaciones.Consultar();
                        if (_reparaciones.EXISTE)
                        {
                            strSolucion3 = _reparaciones.NOMMOT_MRP;
                            strCodigoSolucion3 = _reparaciones.CODMOT_MRP;
                        }
                    }
                }
            }
        }

        private string _strSolucion4;
        public string strSolucion4
        {
            get { return _strSolucion4; }
            set 
            { 
                _strSolucion4 = value; 
                base.OnPropertyChanged("strSolucion4");
                if (strSolucion4 != null)
                {
                    if (strSolucion4.Length == 3)
                    {
                        _reparaciones.CODMOT_MRP = strSolucion4;
                        _reparaciones.Consultar();
                        if (_reparaciones.EXISTE)
                        {
                            strSolucion4 = _reparaciones.NOMMOT_MRP;
                            strCodigoSolucion4 = _reparaciones.CODMOT_MRP;
                        }
                    }
                }
            }
        }

        private string _strSolucion5;
        public string strSolucion5
        {
            get { return _strSolucion5; }
            set 
            { 
                _strSolucion5 = value; 
                base.OnPropertyChanged("strSolucion5");
                if (strSolucion5 != null)
                {
                    if (strSolucion5.Length == 3)
                    {
                        _reparaciones.CODMOT_MRP = strSolucion5;
                        _reparaciones.Consultar();
                        if (_reparaciones.EXISTE)
                        {
                            strSolucion5 = _reparaciones.NOMMOT_MRP;
                            strCodigoSolucion5 = _reparaciones.CODMOT_MRP;
                        }
                    }
                }
            }
        }

        private string _strCodigoSolucion1;
        public string strCodigoSolucion1
        {
            get { return _strCodigoSolucion1; }
            set { _strCodigoSolucion1 = value; base.OnPropertyChanged("strCodigoSolucion1"); }
        }

        private string _strCodigoSolucion2;
        public string strCodigoSolucion2
        {
            get { return _strCodigoSolucion2; }
            set { _strCodigoSolucion2 = value; base.OnPropertyChanged("strCodigoSolucion2"); }
        }

        private string _strCodigoSolucion3;
        public string strCodigoSolucion3
        {
            get { return _strCodigoSolucion3; }
            set { _strCodigoSolucion3 = value; base.OnPropertyChanged("strCodigoSolucion3"); }
        }

        private string _strCodigoSolucion4;
        public string strCodigoSolucion4
        {
            get { return _strCodigoSolucion4; }
            set { _strCodigoSolucion4 = value; base.OnPropertyChanged("strCodigoSolucion4"); }
        }

        private string _strCodigoSolucion5;
        public string strCodigoSolucion5
        {
            get { return _strCodigoSolucion5; }
            set { _strCodigoSolucion5 = value; base.OnPropertyChanged("strCodigoSolucion5"); }
        }

        private string _strTipoSolucion;
        public string strTipoSolucion
        {
            get { return _strTipoSolucion; }
            set { _strTipoSolucion = value; base.OnPropertyChanged("strTipoSolucion"); }
        }

        private string _strProcesoInicial;
        public string strProcesoInicial
        {
            get { return _strProcesoInicial; }
            set { _strProcesoInicial = value; base.OnPropertyChanged("strProcesoInicial"); }
        }

        private DateTime _dtmFecha = DateTime.Now;
        public DateTime dtmFecha
        {
            get { return _dtmFecha; }
            set { _dtmFecha = value; base.OnPropertyChanged("dtmFecha"); }
        }

        private string _strOrden;
        public string strOrden
        {
            get { return _strOrden; }
            set { _strOrden = value; base.OnPropertyChanged("strOrden"); }
        }

        private ObservableCollection<VMProcesarGarSerRec> _lisprocesos = new ObservableCollection<VMProcesarGarSerRec>();
        public ObservableCollection<VMProcesarGarSerRec> lisprocesos
        {
            get { return _lisprocesos; }
            set { _lisprocesos = value; base.OnPropertyChanged("lisprocesos"); }
        }

        private VMProcesarGarSerRec _selproceso;
        public VMProcesarGarSerRec selproceso
        {
            get { return _selproceso; }
            set 
            {  
                _selproceso = value;  
                base.OnPropertyChanged("selproceso");
                if (selproceso != null)
                    cargarCampos();
            }
        }

        private Boolean _logValido = true;
        public Boolean logValido
        {
            get { return _logValido; }
            set { _logValido = value; base.OnPropertyChanged("logValido"); }
        }

        private VMvisorFotoReferencia _visorFotoReferencia = new VMvisorFotoReferencia();
        public VMvisorFotoReferencia visorFotoReferencia
        {
            get { return _visorFotoReferencia; }
            set { _visorFotoReferencia = value; base.OnPropertyChanged("visorFotoReferencia"); }
        }

        private Boolean _IsOpenHabilitarDoc = false;
        public Boolean IsOpenHabilitarDoc
        {
            get { return _IsOpenHabilitarDoc; }
            set { _IsOpenHabilitarDoc = value; base.OnPropertyChanged("IsOpenHabilitarDoc"); }
        }

        private string _strEmpresa;
        public string strEmpresa
        {
            get { return _strEmpresa; }
            set { _strEmpresa = value; base.OnPropertyChanged("strEmpresa"); }
        }

        private string _strOrdenInicial;
        public string strOrdenInicial
        {
            get { return _strOrdenInicial; }
            set 
            { 
                _strOrdenInicial = value; 
                if (value != null)
                {
                    if (value.Length>5)
                    {
                        _ordenes.NROORD_EOP = value;
                        _ordenes.consultar();
                        if (_ordenes.EXISTE)
                        {
                            if (_ordenes.CODREF_EOP != strReferencia || _ordenes.CODCOL_EOP != strColor)
                            {
                                MessageBox.Show("La referencia y el color no corresponden a la orden: " + value, "Inconsistencia", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK);
                                _strOrdenInicial = "";
                            }
                        }
                        else
                        {
                            MessageBox.Show("La orden: " + value + " no existe.", "Inconsistencia", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK);
                            _strOrdenInicial = "";
                        }
                    }
                }
                base.OnPropertyChanged("strOrdenInicial"); 
            }
        }


        // Propiedades para ingresar un documento manual

        private string _strCodigoClienteManual;
        public string strCodigoClienteManual
        {
            get { return _strCodigoClienteManual; }
            set 
            { 
                _strCodigoClienteManual = value; 
                base.OnPropertyChanged("strCodigoClienteManual");
                if (strCodigoClienteManual != null)
                {
                    if (strCodigoClienteManual.Length == 3)
                    {
                        _cliente.CODCLI_CLI = strCodigoClienteManual;
                        _cliente.consultar();
                        if (_cliente.EXISTE)
                            strNombreClienteManual = _cliente.NOMCLI_CLI;
                        else
                        {
                            strNombreClienteManual = "";
                            msn.texto = "El cliente ingresado no existe.";
                            msn.tipo = false;
                        }
                    }
                }
            }
        }

        private string _strNombreClienteManual;
        public string strNombreClienteManual
        {
            get { return _strNombreClienteManual; }
            set { _strNombreClienteManual = value; base.OnPropertyChanged("strNombreClienteManual"); }
        }

        private string _strTipoMovManual;
        public string strTipoMovManual
        {
            get { return _strTipoMovManual; }
            set { _strTipoMovManual = value; base.OnPropertyChanged("strTipoMovManual"); }
        }

        private string _strDocumentoManual;
        public string strDocumentoManual
        {
            get { return _strDocumentoManual; }
            set { _strDocumentoManual = value; base.OnPropertyChanged("strDocumentoManual"); }
        }

        private string _strReparacionManual;
        public string strReparacionManual
        {
            get { return _strReparacionManual; }
            set { _strReparacionManual = value; base.OnPropertyChanged("strReparacionManual"); }
        }

        private string _strControlManual;
        public string strControlManual
        {
            get { return _strControlManual; }
            set { _strControlManual = value; base.OnPropertyChanged("strControlManual"); }
        }

        private string _strReferenciaManual;
        public string strReferenciaManual
        {
            get { return _strReferenciaManual; }
            set 
            { 
                _strReferenciaManual = value; 
                base.OnPropertyChanged("strReferenciaManual");
                if (strReferenciaManual != null)
                {
                    if (strReferenciaManual.Length == 4)
                    {
                        _ref.CODREF_REF = strReferenciaManual;
                        _ref.Consultar();
                        if (_ref.EXISTE == true)
                            strNombreReferenciaManual = _ref.NOMREF_REF;
                        else
                        {
                            strNombreReferenciaManual = "";
                            msn.texto = "La referencia ingresada no existe.";
                            msn.tipo = false;
                        }
                    }
                }
            }
        }

        private string _strNombreReferenciaManual;
        public string strNombreReferenciaManual
        {
            get { return _strNombreReferenciaManual; }
            set { _strNombreReferenciaManual = value; base.OnPropertyChanged("strNombreReferenciaManual"); }
        }

        private string _strColorManual;
        public string strColorManual
        {
            get { return _strColorManual; }
            set 
            { 
                _strColorManual = value; 
                base.OnPropertyChanged("strColorManual");
                if (strColorManual != null)
                {
                    if (strColorManual.Length == 2)
                    {
                        _col.CODCOL_COL = strColorManual;
                        _col.Consultar();
                        strNombreColorManual = _col.NOMCOL_COL;
                        if (strNombreColorManual.Length == 0)
                        {
                            msn.texto = "El color ingresada no existe.";
                            msn.tipo = false;
                        }
                        else
                        {
                            _prod.CODREF_PRO = strReferenciaManual;
                            DataTable dtTemp = _prod.BuscarColor();
                            Boolean logExiste = false;
                            foreach (DataRow dr in dtTemp.Rows)
                            {
                                if (dr["CODIGO"].ToString().Trim() == strColorManual)
                                    logExiste = true;
                            }

                            if (logExiste == false)
                            {
                                msn.texto = "El color ingresado no es valido para la referencia ingresada.";
                                msn.tipo = false;
                                strColorManual = "";
                                strNombreColorManual = "";
                            }
                        }
                    }
                }
            }
        }

        private string _strNombreColorManual;
        public string strNombreColorManual
        {
            get { return _strNombreColorManual; }
            set { _strNombreColorManual = value; base.OnPropertyChanged("strNombreColorManual"); }
        }

        private string _strTallaManual;
        public string strTallaManual
        {
            get { return _strTallaManual; }
            set 
            { 
                _strTallaManual = value; 
                base.OnPropertyChanged("strTallaManual");
                if (strTallaManual != null)
                {
                    if (strTallaManual.Length == 2)
                    {
                        _prod.CODREF_PRO = strReferenciaManual;
                        _prod.CODCOL_PRO = strColorManual;
                        DataTable dtTemp = _prod.BuscarTallas();
                        Boolean logExiste = false;
                        foreach (DataRow dr in dtTemp.Rows)
                        {
                            if (dr["TALLA"].ToString().Trim() == strTallaManual)
                                logExiste = true;
                        }

                        if (logExiste == false)
                        {
                            msn.texto = "La talla ingresada no es valida para la referencia y color ingresado";
                            msn.tipo = false;
                            strTallaManual = "";
                        }
                    }
                }
            }
        }

        private string _strMotivo1Manual;
        public string strMotivo1Manual
        {
            get { return _strMotivo1Manual; }
            set { _strMotivo1Manual = value; base.OnPropertyChanged("strMotivo1Manual"); }
        }

        private string _strMotivo2Manual;
        public string strMotivo2Manual
        {
            get { return _strMotivo2Manual; }
            set { _strMotivo2Manual = value; base.OnPropertyChanged("strMotivo2Manual"); }
        }

        private string _strMotivo3Manual;
        public string strMotivo3Manual
        {
            get { return _strMotivo3Manual; }
            set { _strMotivo3Manual = value; base.OnPropertyChanged("strMotivo3Manual"); }
        }

        private string _strMotivo4Manual;
        public string strMotivo4Manual
        {
            get { return _strMotivo4Manual; }
            set { _strMotivo4Manual = value; base.OnPropertyChanged("strMotivo4Manual"); }
        }

        private string _strMotivo5Manual;
        public string strMotivo5Manual
        {
            get { return _strMotivo5Manual; }
            set { _strMotivo5Manual = value; base.OnPropertyChanged("strMotivo5Manual"); }
        }

        private string _strObservacionManual;
        public string strObservacionManual
        {
            get { return _strObservacionManual; }
            set { _strObservacionManual = value; base.OnPropertyChanged("strObservacionManual"); }
        }

        private MDOgeneral.mensaje _msn = new MDOgeneral.mensaje();
        public MDOgeneral.mensaje msn
        {
            get { return _msn; }
            set { _msn = value; base.OnPropertyChanged("msn"); }
        }

        private Boolean _IsOpenIngresoManual = false;
        public Boolean IsOpenIngresoManual
        {
            get { return _IsOpenIngresoManual; }
            set { _IsOpenIngresoManual = value; base.OnPropertyChanged("IsOpenIngresoManual"); }
        }

        private VMbuscarGeneral _buscarCliente;
        public VMbuscarGeneral buscarCliente
        {
            get { return _buscarCliente; }
            set { _buscarCliente = value; base.OnPropertyChanged("buscarCliente"); }
        }

        private VMbuscarReferencia _buscarReferencia;
        public VMbuscarReferencia buscarReferencia
        {
            get { return _buscarReferencia; }
            set { _buscarReferencia = value; base.OnPropertyChanged("buscarReferencia"); }
        }

        private string _strObservacionesEnc;
        public string strObservacionesEnc
        {
            get { return _strObservacionesEnc; }
            set {_strObservacionesEnc = value; base.OnPropertyChanged("strObservacionesEnc"); }
        }
        //


        // Propiedades para copiar y pegar
        private string _strDaño1C;
        public string strDaño1C
        {
            get { return _strDaño1C; }
            set { _strDaño1C = value; base.OnPropertyChanged("strDaño1C"); }
        }

        private string _strDaño2C;
        public string strDaño2C
        {
            get { return _strDaño2C; }
            set { _strDaño2C = value; base.OnPropertyChanged("strDaño2C"); }
        }

        private string _strDaño3C;
        public string strDaño3C
        {
            get { return _strDaño3C; }
            set { _strDaño3C = value; base.OnPropertyChanged("strDaño3C"); }
        }

        private string _strDaño4C;
        public string strDaño4C
        {
            get { return _strDaño4C; }
            set { _strDaño4C = value; base.OnPropertyChanged("strDaño4C"); }
        }

        private string _strDaño5C;
        public string strDaño5C
        {
            get { return _strDaño5C; }
            set { _strDaño5C = value; base.OnPropertyChanged("strDaño5C"); }
        }

        private string _strCodigoDaño1C;
        public string strCodigoDaño1C
        {
            get { return _strCodigoDaño1C; }
            set { _strCodigoDaño1C = value; base.OnPropertyChanged("strCodigoDaño1C"); }
        }

        private string _strCodigoDaño2C;
        public string strCodigoDaño2C
        {
            get { return _strCodigoDaño2C; }
            set { _strCodigoDaño2C = value; base.OnPropertyChanged("strCodigoDaño2C"); }
        }

        private string _strCodigoDaño3C;
        public string strCodigoDaño3C
        {
            get { return _strCodigoDaño3C; }
            set { _strCodigoDaño3C = value; base.OnPropertyChanged("strCodigoDaño3C"); }
        }

        private string _strCodigoDaño4C;
        public string strCodigoDaño4C
        {
            get { return _strCodigoDaño4C; }
            set { _strCodigoDaño4C = value; base.OnPropertyChanged("strCodigoDaño4C"); }
        }

        private string _strCodigoDaño5C;
        public string strCodigoDaño5C
        {
            get { return _strCodigoDaño5C; }
            set { _strCodigoDaño5C = value; base.OnPropertyChanged("strCodigoDaño5C"); }
        }

        private string _strSolucion1C;
        public string strSolucion1C
        {
            get { return _strSolucion1C; }
            set { _strSolucion1C = value; base.OnPropertyChanged("strSolucion1C"); }
        }

        private string _strSolucion2C;
        public string strSolucion2C
        {
            get { return _strSolucion2C; }
            set { _strSolucion2C = value; base.OnPropertyChanged("strSolucion2C"); }
        }

        private string _strSolucion3C;
        public string strSolucion3C
        {
            get { return _strSolucion3C; }
            set { _strSolucion3C = value; base.OnPropertyChanged("strSolucion3C"); }
        }

        private string _strSolucion4C;
        public string strSolucion4C
        {
            get { return _strSolucion4C; }
            set { _strSolucion4C = value; base.OnPropertyChanged("strSolucion4C"); }
        }

        private string _strSolucion5C;
        public string strSolucion5C
        {
            get { return _strSolucion5C; }
            set { _strSolucion5C = value; base.OnPropertyChanged("strSolucion5C"); }
        }

        private string _strCodigoSolucion1C;
        public string strCodigoSolucion1C
        {
            get { return _strCodigoSolucion1C; }
            set { _strCodigoSolucion1C = value; base.OnPropertyChanged("strCodigoSolucion1C"); }
        }

        private string _strCodigoSolucion2C;
        public string strCodigoSolucion2C
        {
            get { return _strCodigoSolucion2C; }
            set { _strCodigoSolucion2C = value; base.OnPropertyChanged("strCodigoSolucion2C"); }
        }

        private string _strCodigoSolucion3C;
        public string strCodigoSolucion3C
        {
            get { return _strCodigoSolucion3C; }
            set { _strCodigoSolucion3C = value; base.OnPropertyChanged("strCodigoSolucion3C"); }
        }

        private string _strCodigoSolucion4C;
        public string strCodigoSolucion4C
        {
            get { return _strCodigoSolucion4C; }
            set { _strCodigoSolucion4C = value; base.OnPropertyChanged("strCodigoSolucion4C"); }
        }

        private string _strCodigoSolucion5C;
        public string strCodigoSolucion5C
        {
            get { return _strCodigoSolucion5C; }
            set { _strCodigoSolucion5C = value; base.OnPropertyChanged("strCodigoSolucion5C"); }
        }

        private string _strTipoSolucionC;
        public string strTipoSolucionC
        {
            get { return _strTipoSolucionC; }
            set { _strTipoSolucionC = value; base.OnPropertyChanged("strTipoSolucionC"); }
        }

        private string _strProcesoInicialC;
        public string strProcesoInicialC
        {
            get { return _strProcesoInicial; }
            set { _strProcesoInicial = value; base.OnPropertyChanged("strProcesoInicial"); }
        }
        
        private string _strOrdenC;
        public string strOrdenC
        {
            get { return _strOrdenC; }
            set { _strOrdenC = value; base.OnPropertyChanged("strOrdenC"); }
        }

        private CLSTABPIE _selpiezaC = new CLSTABPIE();
        public CLSTABPIE selpiezaC
        {
            get { return _selpiezaC; }
            set { _selpiezaC = value; base.OnPropertyChanged("selpiezaC"); }
        }

        private CLSMAEEMPP _selresponsableC = new CLSMAEEMPP();
        public CLSMAEEMPP selresponsableC
        {
            get { return _selresponsableC; }
            set { _selresponsableC = value; base.OnPropertyChanged("selresponsableC"); }
        }

        private CLSTABCAU _selcausaC = new CLSTABCAU();
        public CLSTABCAU selcausaC
        {
            get { return _selcausaC; }
            set { _selcausaC = value; base.OnPropertyChanged("selcausaC"); }
        }

        private CLSTABSOL _selsolucionC = new CLSTABSOL();
        public CLSTABSOL selsolucionC
        {
            get { return _selsolucionC; }
            set { _selsolucionC = value; base.OnPropertyChanged("selsolucionC"); }
        }

        private CLSMAEEMPP _seldesicionC = new CLSMAEEMPP();
        public CLSMAEEMPP seldesicionC
        {
            get { return _seldesicionC; }
            set { _seldesicionC = value; base.OnPropertyChanged("seldesicionC"); }
        }

        private string _strObservacionesEncC;
        public string strObservacionesEncC
        {
            get { return _strObservacionesEncC; }
            set { _strObservacionesEncC = value; base.OnPropertyChanged("strObservacionesEncC"); }
        }

        private Boolean _logPegar = false;
        public Boolean logPegar
        {
            get { return _logPegar; }
            set { _logPegar = value; base.OnPropertyChanged("logPegar"); }
        }

        //

        // Para mostrar mensaje cuando exista un documento ingresado
        private Boolean _IsOpenMensaje = false;
        public Boolean IsOpenMensaje
        {
            get { return _IsOpenMensaje; }
            set { _IsOpenMensaje = value; base.OnPropertyChanged("IsOpenMensaje"); }
        }

        private string _strMensaje;
        public string strMensaje
        {
            get { return _strMensaje; }
            set { _strMensaje = value; base.OnPropertyChanged("strMensaje"); }
        }

        private DataTable _dtDocumento;
        public DataTable dtDocumento
        {
            get { return _dtDocumento; }
            set { _dtDocumento = value; base.OnPropertyChanged("dtDocumento"); }
        }
        //

        #endregion

        #region Comandos
        
        RelayCommand _cmdSalir;
        public ICommand cmdSalir
        {
            get
            {
                if (_cmdSalir == null)
                {
                    _cmdSalir = new RelayCommand(Salir);
                }
                return _cmdSalir;
            }
        }

        RelayCommand _cmdBuscarDaño;
        public ICommand cmdBuscarDaño
        {
            get
            {
                if (_cmdBuscarDaño == null)
                {
                    _cmdBuscarDaño = new RelayCommand(buscarDaños);
                }
                return _cmdBuscarDaño;
            }
        }

        RelayCommand _cmdBuscarSolucion;
        public ICommand cmdBuscarSolucion
        {
            get
            {
                if (_cmdBuscarSolucion == null)
                {
                    _cmdBuscarSolucion = new RelayCommand(buscarSoluciones);
                }
                return _cmdBuscarSolucion;
            }
        }

        RelayCommand _cmdGrabar;
        public ICommand cmdGrabar
        {
            get
            {
                if (_cmdGrabar == null)
                {
                    _cmdGrabar = new RelayCommand(r => grabar());
                }
                return _cmdGrabar;
            }
        }

        RelayCommand _cmdGuardarDoc;
        public ICommand cmdGuardarDoc
        {
            get
            {
                if (_cmdGuardarDoc == null)
                {
                    _cmdGuardarDoc = new RelayCommand(r => guardarDocumento());
                }
                return _cmdGuardarDoc;
            }
        }

        RelayCommand _cmdSalirDoc;
        public ICommand cmdSalirDoc
        {
            get
            {
                if (_cmdSalirDoc == null)
                {
                    _cmdSalirDoc = new RelayCommand(r => SalirDoc());
                }
                return _cmdSalirDoc;
            }
        }

        RelayCommand _cmdAgregarReparacionManual;
        public ICommand cmdAgregarReparacionManual
        {
            get
            {
                if (_cmdAgregarReparacionManual == null)
                {
                    _cmdAgregarReparacionManual = new RelayCommand(r => agregarReparacionManual());
                }
                return _cmdAgregarReparacionManual;
            }
        }

        RelayCommand _cmdBuscarCliente;
        public ICommand cmdBuscarCliente
        {
            get
            {
                if (_cmdBuscarCliente == null)
                {
                    _cmdBuscarCliente = new RelayCommand(r => buscar_cliente());
                }
                return _cmdBuscarCliente;
            }
        }

        RelayCommand _cmdBuscarReferencia;
        public ICommand cmdBuscarReferencia
        {
            get
            {
                if (_cmdBuscarReferencia == null)
                {
                    _cmdBuscarReferencia = new RelayCommand(x => BuscarReferencia());
                }
                return _cmdBuscarReferencia;
            }
        }

        RelayCommand _cmdSalirIngresoManual;
        public ICommand cmdSalirIngresoManual
        {
            get
            {
                if (_cmdSalirIngresoManual == null)
                {
                    _cmdSalirIngresoManual = new RelayCommand(r => SalirIngresoManual());
                }
                return _cmdSalirIngresoManual;
            }
        }

        RelayCommand _cmdGuardarIngresoManual;
        public ICommand cmdGuardarIngresoManual
        {
            get
            {
                if (_cmdGuardarIngresoManual == null)
                {
                    _cmdGuardarIngresoManual = new RelayCommand(r => guardarIngresoManual());
                }
                return _cmdGuardarIngresoManual;
            }
        }

        RelayCommand _cmdCopiar;
        public ICommand cmdCopiar
        {
            get
            {
                if (_cmdCopiar == null)
                {
                    _cmdCopiar = new RelayCommand(r => copiarvariables());
                }
                return _cmdCopiar;
            }
        }

        RelayCommand _cmdPegar;
        public ICommand cmdPegar
        {
            get
            {
                if (_cmdPegar == null)
                {
                    _cmdPegar = new RelayCommand(r => pegarvariables());
                }
                return _cmdPegar;
            }
        }

        RelayCommand _cmdSalirMensaje;
        public ICommand cmdSalirMensaje
        {
            get
            {
                if (_cmdSalirMensaje == null)
                {
                    _cmdSalirMensaje = new RelayCommand(r => SalirMensaje());
                }
                return _cmdSalirMensaje;
            }
        }

        #endregion

        #region Metodos

        // Metodos que se una para el ingreso manual
        private void cargarClientes()
        {
            try
            {
                List<CLSMAECLIP> lisclientes = new CLSMAECLIP().listaCliente();
                _buscarCliente = new VMbuscarGeneral((from cli in lisclientes
                                                      select new
                                                          VMlistaGenerica { strColumna1 = cli.CODCLI_CLI, strColumna2 = cli.NOMCLI_CLI, strColumna3 = cli.NITCLI_CLI }).ToList());
                buscarCliente.PropertyChanged += onBuscarClientePropertyChanged;
                buscarCliente.gridBuscar.columna1.strNombre = "Código";
                buscarCliente.gridBuscar.columna2.strNombre = "Nombre                       ";
                buscarCliente.gridBuscar.columna3.strNombre = "Nit           ";                
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        void onBuscarClientePropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            try
            {
                if (e.PropertyName == "IsOpen")
                {
                    if (!buscarCliente.IsOpen)
                    {
                        if (buscarCliente.gridBuscar.selLista != null)
                        {
                            strCodigoClienteManual = buscarCliente.gridBuscar.selLista.strColumna1;
                            strNombreClienteManual = buscarCliente.gridBuscar.selLista.strColumna2;
                        }
                    }
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        private void cargarReferencias()
        {
            try
            {
                buscarReferencia = new VMbuscarReferencia();
                buscarReferencia.TieneColor = true;
                buscarReferencia.PropertyChanged += onBuscarReferenciaPropertyChanged;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        void onBuscarReferenciaPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            try
            {
                if (e.PropertyName == "IsOpen")
                {
                    if (!buscarReferencia.IsOpen)
                    {
                        foreach (string x in buscarReferencia.listaProducto)
                        {
                            strReferenciaManual = x.Substring(0,4);
                            strColorManual = x.Substring(4,2);
                        }
                        _ref.CODREF_REF = strReferenciaManual;
                        _ref.Consultar();
                        if (_ref.EXISTE)
                            strNombreReferenciaManual = _ref.NOMREF_REF;

                        _col.CODCOL_COL = strColorManual;
                        _col.Consultar();
                        strNombreColorManual = _col.NOMCOL_COL;                        
                    }
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        private void buscar_cliente()
        {
            try
            {
                buscarCliente.IsOpen = true;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public void BuscarReferencia()
        {
            try
            {
                buscarReferencia.IsOpen = true;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        void agregarReparacionManual()
        {
            try
            {
                limpiarIngresoManual();
                consecutivoReparacionManual();
                IsOpenIngresoManual = true;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        void guardarIngresoManual()
        {
            try
            {
                if (validaCamposIngresoManual() == true)
                {
                    // Se agrega la reparacion
                    StrConsulta = "insert into reppendp (CODCLI_RPN, NRODOC_RPN, TIPO_RPN, NROREP_RPN, NROCON_RPN, CODREF_RPN, CODCOL_RPN, CODTAL_RPN, MOTIVO1_RPN, MOTIVO2_RPN, MOTIVO3_RPN, MOTIVO4_RPN, MOTIVO5_RPN, OBSERV_RPN) values (";
                    StrConsulta = StrConsulta + "'" + strCodigoClienteManual + "', '" + strDocumentoManual + "', '" + strTipoMovManual + "', '" + strReparacionManual + "', '" + strControlManual + "', '" + strReferenciaManual + "', '" + strColorManual + "', '" + strTallaManual + "', '" + strMotivo1Manual + "', '" + strMotivo2Manual + "', '" + strMotivo3Manual + "', '" + strMotivo4Manual + "', '" + strMotivo5Manual + "', '" + strObservacionManual + "')" ;
                    mod.comando(StrConsulta);

                    // Se actualiza el consecutivo en la tabla de control
                    StrConsulta = "update controlp set nom_con = '" + strControlManual + "' where id_con = 'REP' and cod_con = 'MAN'";
                    mod.comando(StrConsulta);

                    // Se actualiza el listado de pendientes
                    if (selcliente.CODCLI_CLI != null)
                        consultarReparaciones(selcliente.CODCLI_CLI);
                    else
                        consultarReparaciones("ZZZ");

                    strNroDocumento = strControlManual;

                    selproceso = lisprocesos[0];

                    IsOpenIngresoManual = false;
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        Boolean validaCamposIngresoManual()
        {
            try
            {
                if (strCodigoClienteManual == null)
                {
                    msn.texto = "Falta ingresar el cliente."; 
                    msn.tipo = false; 
                    return false;
                }
                if (strNombreClienteManual == null) 
                { 
                    msn.texto = "Cliente no existe.";
                    msn.tipo = false;
                    return false;
                }
                if (strTipoMovManual == null)
                {
                    msn.texto = "Falta ingresar el tipo de reparación.";
                    msn.tipo = false;
                    return false;
                }
                if (strReferenciaManual == null) 
                { 
                    msn.texto = "Falta ingresar la referencia.";
                    msn.tipo = false;
                    return false;                     
                }
                if (strNombreReferenciaManual == null) 
                {
                    msn.texto = "Referencia no existe.";
                    msn.tipo = false;
                    return false; 
                }
                if (strColorManual == null) 
                {
                    msn.texto = "Falta ingresar el color.";
                    msn.tipo = false;
                    return false; 
                }
                if (strNombreColorManual == null) 
                {
                    msn.texto = "Color no existe.";
                    msn.tipo = false;
                    return false; 
                }
                if (strTallaManual == null) 
                {
                    msn.texto = "Falta ingresar la talla.";
                    msn.tipo = false;
                    return false; 
                }
                if (strTallaManual.Length != 2) 
                {
                    msn.texto = "Falta ingresar la talla.";
                    msn.tipo = false;
                    return false; 
                }
                if (strMotivo1Manual == null) 
                {
                    msn.texto = "Falta ingresar minimo un motivo.";
                    msn.tipo = false;
                    return false; 
                }

                return true;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return true;
        }

        void consecutivoReparacionManual()
        {
            try
            {
                string strConsecutivo="";
                StrConsulta = "SELECT nom_con as Consecutivo FROM controlp where id_con = 'REP' and cod_con = 'MAN'";
                DtConsulta = mod.consulta(StrConsulta);//FJRF - Consultamos los datos
                if (DtConsulta.Rows.Count == 1)
                {
                    strConsecutivo = DtConsulta.Rows[0][0].ToString().Trim();
                    strReparacionManual = strConsecutivo.Substring(0,2) + (Convert.ToInt32(strConsecutivo.Substring(2, 5)) + 1).ToString().PadLeft(5, '0');
                    strControlManual = strReparacionManual;
                    strDocumentoManual = strReparacionManual;
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        void limpiarIngresoManual()
        {
            try
            {
                strCodigoClienteManual = null;
                strNombreClienteManual = null;
                strDocumentoManual = null;
                strReparacionManual = null;
                strControlManual = null;
                strTipoMovManual = null;
                strReferenciaManual = null;
                strNombreReferenciaManual = null;
                strColorManual = null;
                strNombreColorManual = null;
                strTallaManual = null;
                strMotivo1Manual = null;
                strMotivo2Manual = null;
                strMotivo3Manual = null;
                strMotivo4Manual = null;
                strMotivo5Manual = null;
                strObservacionManual = null;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        // Fin Metodos que se una para el ingreso manual

        void consultarReparaciones(string strCliente)
        {
            try
            {
                int numContador = 0;
                //Primero se valida que el documento ya este grabado en 
                if (strNroDocumento != null)
                {
                    if ( strNroDocumento.Length == 7)
                        dtDocumento = _gar.consultaDocumento(strNroDocumento);
                }                

                if (dtDocumento.Rows.Count > 0)
                {
                    strMensaje = "Documento ya existe. Y generó las siguientes ordenes: ";
                    IsOpenMensaje = true;
                }
                else
                {
                    List<MGarantiasServiciosyReconocidos> lisrep = new List<MGarantiasServiciosyReconocidos>();
                    lisrep = _gar.listarReparaciones(strCliente, strTipoFiltro, strNroDocumento);

                    List<VMProcesarGarSerRec> all = (from lis in lisrep select new VMProcesarGarSerRec(lis)).ToList();
                    foreach (VMProcesarGarSerRec xx in all)
                    {
                        numContador = numContador + 1;
                    }
                    lisprocesos.Clear();
                    lisprocesos = new ObservableCollection<VMProcesarGarSerRec>(all);

                    if (strNroDocumento != null)
                    {
                        if (strNroDocumento.Length == 7)
                        {
                            if (lisprocesos.Count == 0)
                                IsOpenHabilitarDoc = true;
                            else
                                selproceso = lisprocesos[0];

                        }
                    }
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public void buscarDaños(object intcontador)
        {
            try
            {
                _numBusqueda = Convert.ToInt32(intcontador);

                DataTable dt = new DataTable();
                FRMbuscar frm = new FRMbuscar(_daños, "buscar", "Codigo", "NOMDAN_MDN", "Codigo");
                frm.ShowDialog();
                
                if (_numBusqueda == 1)
                {
                    strCodigoDaño1 = frm.retorno;
                    if (strCodigoDaño1 != "")
                    {
                        _daños.CODDAN_MDN = strCodigoDaño1;
                        _daños.Consultar();
                        if (_daños.EXISTE)
                            strDaño1 = _daños.NOMDAN_MDN;
                    }
                }

                if (_numBusqueda == 2)
                {
                    strCodigoDaño2 = frm.retorno;
                    if (strCodigoDaño2 != "")
                    {
                        _daños.CODDAN_MDN = strCodigoDaño2;
                        _daños.Consultar();
                        if (_daños.EXISTE)
                            strDaño2 = _daños.NOMDAN_MDN;
                    }
                }

                if (_numBusqueda == 3)
                {
                    strCodigoDaño3 = frm.retorno;
                    if (strCodigoDaño3 != "")
                    {
                        _daños.CODDAN_MDN = strCodigoDaño3;
                        _daños.Consultar();
                        if (_daños.EXISTE)
                            strDaño3 = _daños.NOMDAN_MDN;
                    }
                }

                if (_numBusqueda == 4)
                {
                    strCodigoDaño4 = frm.retorno;
                    if (strCodigoDaño4 != "")
                    {
                        _daños.CODDAN_MDN = strCodigoDaño4;
                        _daños.Consultar();
                        if (_daños.EXISTE)
                            strDaño4 = _daños.NOMDAN_MDN;
                    }
                }

                if (_numBusqueda == 5)
                {
                    strCodigoDaño5 = frm.retorno;
                    if (strCodigoDaño5 != "")
                    {
                        _daños.CODDAN_MDN = strCodigoDaño5;
                        _daños.Consultar();
                        if (_daños.EXISTE)
                            strDaño5 = _daños.NOMDAN_MDN;
                    }
                }

            }
            catch (Exception ex) { throw ex; }
        }

        public void buscarSoluciones(object intcontador)
        {
            try
            {
                _numBusquedaSol = Convert.ToInt32(intcontador);

                DataTable dt = new DataTable();
                FRMbuscar frm = new FRMbuscar(_reparaciones, "buscar", "Codigo", "NOMMOT_MRP", "Codigo");
                frm.ShowDialog();

                if (_numBusquedaSol == 1)
                {
                    strCodigoSolucion1 = frm.retorno;
                    if (strCodigoSolucion1 != "")
                    {
                        _reparaciones.CODMOT_MRP = strCodigoSolucion1;
                        _reparaciones.Consultar();
                        if (_reparaciones.EXISTE)
                            strSolucion1 = _reparaciones.NOMMOT_MRP;
                    }
                }

                if (_numBusquedaSol == 2)
                {
                    strCodigoSolucion2 = frm.retorno;
                    if (strCodigoSolucion2 != "")
                    {
                        _reparaciones.CODMOT_MRP = strCodigoSolucion2;
                        _reparaciones.Consultar();
                        if (_reparaciones.EXISTE)
                            strSolucion2 = _reparaciones.NOMMOT_MRP;
                    }
                }

                if (_numBusquedaSol == 3)
                {
                    strCodigoSolucion3 = frm.retorno;
                    if (strCodigoSolucion3 != "")
                    {
                        _reparaciones.CODMOT_MRP = strCodigoSolucion3;
                        _reparaciones.Consultar();
                        if (_reparaciones.EXISTE)
                            strSolucion3 = _reparaciones.NOMMOT_MRP;
                    }
                }

                if (_numBusquedaSol == 4)
                {
                    strCodigoSolucion4 = frm.retorno;
                    if (strCodigoSolucion4 != "")
                    {
                        _reparaciones.CODMOT_MRP = strCodigoSolucion4;
                        _reparaciones.Consultar();
                        if (_reparaciones.EXISTE)
                            strSolucion4 = _reparaciones.NOMMOT_MRP;
                    }
                }

                if (_numBusquedaSol == 5)
                {
                    strCodigoSolucion5 = frm.retorno;
                    if (strCodigoSolucion5 != "")
                    {
                        _reparaciones.CODMOT_MRP = strCodigoSolucion5;
                        _reparaciones.Consultar();
                        if (_reparaciones.EXISTE)
                            strSolucion5 = _reparaciones.NOMMOT_MRP;
                    }
                }
            }
            catch (Exception ex) { throw ex; }
        }

        void cargarCampos()
        {
            try
            {
                strCodigoCliente = selproceso.strCodigoCliente;
                strNombreCliente = selproceso.strNombreCliente;
                strDocumento = selproceso.strDocumento;
                
                string StrTipo1 = "";

                if (selproceso.strTipo.Trim()=="Garantia")
                    StrTipo1 = "G";
                if (selproceso.strTipo.Trim() == "Servicio")
                    StrTipo1 = "S";
                if (selproceso.strTipo.Trim() == "Reparacion")
                    StrTipo1 = "R";
                if (selproceso.strTipo.Trim() == "Reconocido")
                    StrTipo1 = "C";
                if (selproceso.strTipo.Trim() == "Devolucion")
                    StrTipo1 = "D";

                strTipoMov = "";
                strTipoMov = StrTipo1;

                strReparacion = selproceso.strReparacion;
                strControl = selproceso.strControl;
                strReferencia = selproceso.strReferencia;
                strNombreReferencia = selproceso.strNombreReferencia;
                strColor = selproceso.strColor;
                strNombreColor = selproceso.strNombreColor;
                strTalla = selproceso.strTalla;
                strMotivo1 = selproceso.strMotivo1;
                strMotivo2 = selproceso.strMotivo2;
                strMotivo3 = selproceso.strMotivo3;
                strMotivo4 = selproceso.strMotivo4;
                strMotivo5 = selproceso.strMotivo5;
                strObservacion = selproceso.strObservacion;
                strObservacionesEnc = null;
                visorFotoReferencia.strCodigo = strReferencia;
                visorFotoReferencia.strColor = strColor;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public void grabar()
        {
            try
            {
                Mouse.OverrideCursor = Cursors.Wait;

                string strcodPieza = "   ";
                string strcodResponsable = "     ";
                string strcodCausa = "   ";
                string strcodSolucion = "   ";
                string strcodDesicion = "     ";
                string strOrdIni = "       ";

                if (selpieza != null)
                {
                    if (selpieza.CODPIE_PIE != null)
                    {
                        strcodPieza = selpieza.CODPIE_PIE;
                    }
                }

                if (selresponsable != null)
                {
                    if (selresponsable.CODEMP_EMP != null)
                    {
                        strcodResponsable = selresponsable.CODEMP_EMP;
                    }
                }

                if (selcausa != null)
                {
                    if (selcausa.CODCAU_CAU != null)
                    {
                        strcodCausa = selcausa.CODCAU_CAU;
                    }
                }

                if (selsolucion != null)
                {
                    if (selsolucion.CODSOL_SOL != null)
                    {
                        strcodSolucion = selsolucion.CODSOL_SOL;
                    }
                }

                if (seldesicion != null)
                {
                    if (seldesicion.CODEMP_EMP != null)
                    {
                        strcodDesicion = seldesicion.CODEMP_EMP;
                    }
                }

                if (strOrdenInicial != null)
                {
                    strOrdIni = strOrdenInicial;
                }

                MDOgeneral.spComando.CommandText = "SP_GRABARREPP";
                MDOgeneral.spComando.Connection = MDOgeneral.conexion;
                MDOgeneral.spComando.CommandType = CommandType.StoredProcedure;
                MDOgeneral.spComando.Parameters.Clear();

                //Input
                MDOgeneral.spComando.Parameters.Add("pva_codcli", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strCodigoCliente;
                MDOgeneral.spComando.Parameters["pva_codcli"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_nrodoc", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strDocumento;
                MDOgeneral.spComando.Parameters["pva_nrodoc"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_tipo", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strTipoMov;
                MDOgeneral.spComando.Parameters["pva_tipo"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_nrorep", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strReparacion;
                MDOgeneral.spComando.Parameters["pva_nrorep"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_mot1", Oracle.DataAccess.Client.OracleDbType.Varchar2, 200).Value = strCodigoDaño1;
                MDOgeneral.spComando.Parameters["pva_mot1"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_mot2", Oracle.DataAccess.Client.OracleDbType.Varchar2, 200).Value = strCodigoDaño2;
                MDOgeneral.spComando.Parameters["pva_mot2"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_mot3", Oracle.DataAccess.Client.OracleDbType.Varchar2, 200).Value = strCodigoDaño3;
                MDOgeneral.spComando.Parameters["pva_mot3"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_mot4", Oracle.DataAccess.Client.OracleDbType.Varchar2, 200).Value = strCodigoDaño4;
                MDOgeneral.spComando.Parameters["pva_mot4"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_mot5", Oracle.DataAccess.Client.OracleDbType.Varchar2, 200).Value = strCodigoDaño5;
                MDOgeneral.spComando.Parameters["pva_mot5"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_prc1", Oracle.DataAccess.Client.OracleDbType.Varchar2, 200).Value = strCodigoSolucion1;
                MDOgeneral.spComando.Parameters["pva_prc1"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_prc2", Oracle.DataAccess.Client.OracleDbType.Varchar2, 200).Value = strCodigoSolucion2;
                MDOgeneral.spComando.Parameters["pva_prc2"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_prc3", Oracle.DataAccess.Client.OracleDbType.Varchar2, 200).Value = strCodigoSolucion3;
                MDOgeneral.spComando.Parameters["pva_prc3"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_prc4", Oracle.DataAccess.Client.OracleDbType.Varchar2, 200).Value = strCodigoSolucion4;
                MDOgeneral.spComando.Parameters["pva_prc4"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_prc5", Oracle.DataAccess.Client.OracleDbType.Varchar2, 200).Value = strCodigoSolucion5;
                MDOgeneral.spComando.Parameters["pva_prc5"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_tiprep", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strTipoSolucion;
                MDOgeneral.spComando.Parameters["pva_tiprep"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_prcini", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strProcesoInicial;
                MDOgeneral.spComando.Parameters["pva_prcini"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pdt_fecha", Oracle.DataAccess.Client.OracleDbType.Date).Value = dtmFecha.Date;
                MDOgeneral.spComando.Parameters["pdt_fecha"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_codpie", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strcodPieza;
                MDOgeneral.spComando.Parameters["pva_codpie"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_codres", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strcodResponsable;
                MDOgeneral.spComando.Parameters["pva_codres"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_codcau", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strcodCausa;
                MDOgeneral.spComando.Parameters["pva_codcau"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_codsol", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strcodSolucion;
                MDOgeneral.spComando.Parameters["pva_codsol"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_coddec", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strcodDesicion;
                MDOgeneral.spComando.Parameters["pva_coddec"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_ordenini", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strOrdIni;
                MDOgeneral.spComando.Parameters["pva_ordenini"].Direction = ParameterDirection.Input;

                MDOgeneral.spComando.Parameters.Add("pva_observ", Oracle.DataAccess.Client.OracleDbType.Varchar2, 200).Value = strObservacionesEnc;
                MDOgeneral.spComando.Parameters["pva_observ"].Direction = ParameterDirection.Input;


                //Output
                MDOgeneral.spComando.Parameters.Add("pva_result", Oracle.DataAccess.Client.OracleDbType.Varchar2, 2000).Direction = ParameterDirection.Output;
                MDOgeneral.spComando.Parameters.Add("pva_errusu", Oracle.DataAccess.Client.OracleDbType.Varchar2, 2000).Direction = ParameterDirection.Output;
                MDOgeneral.spComando.ExecuteNonQuery();
                strOrden = MDOgeneral.spComando.Parameters["pva_errusu"].Value.ToString();

                Mouse.OverrideCursor = Cursors.Arrow;

                //imprimirOrden(strOrden);//FJRF - Este era el que tenia, se remplaza por el envio a otro formulario (FrmForularioDeSalidas) para hacer la impresion por cmd (01)

                //FJRF - ESTO IMPRIME DE FORMA DIRECTA (02)
                if (strTipoSolucion != "C")
                {
                    frmSalMP FrmForularioDeSalidas = new frmSalMP();//FJRF - Creamos un formulario que maneje

                    MDOgeneral.strImprimirNoCopias = "0-VMGarantiasServiciosyReconocidos(Grabar)";//FJRF enviamos el numero de copias y en nombre de donde se procesa la funcion (Le decimos que cero para que no imprima nada por esta opcion)

                    FrmForularioDeSalidas.StrCodigoOrdenAutomatica = strOrden;//FJRF - Enviamos el numero de la orden al formulario
                    FrmForularioDeSalidas.dgSalida.Focus();//FJRF - Ponemos el foco en el grid
                    FrmForularioDeSalidas.ShowDialog();//FJRF - Activimos el formulario
                }
                PttV_ImprimirEnCrystalReport();//FJRF - ImprimimosEnCrystalReport en la impresora pequeña (03)
                

                MessageBox.Show("Se grabo la reparación y se generó el la orden de producción numero " + strOrden.Trim(), "Confirmación", MessageBoxButton.OK, MessageBoxImage.Information, MessageBoxResult.OK);

                limpiar();

                if (selcliente != null)
                {
                    if (selcliente.CODCLI_CLI != null)
                        consultarReparaciones(selcliente.CODCLI_CLI);
                }
                else
                    consultarReparaciones("ZZZ");

            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        protected void PttV_ImprimirEnCrystalReport()
        {
            try//FJRF - Validamos el proceso de impresion 
            {

                String StrRutaReporteAImprimir = StrRutaReporteCrystalReport + "rptImpresoraDymoImprimirOrden.rpt";//FJRF - Armamos la ruta completa donde estara el reporte
                if (System.IO.File.Exists(StrRutaReporteAImprimir) == true)//FJRf - Si el reporte existe hacemos lo siguiente
                {
                    StrConsulta = "SELECT NROORD_TMP,  CODCLI_TMP,  NOMCLI_TMP,  FECORD_TMP,  CODREF_TMP,  CODCOL_TMP,  CODTAL_TMP,  NOMREF_TMP,  NOMCOL_TMP,  DANO_TMP, PROCESO_TMP, NROREP_TMP, SECCION_TMP, OBSERV_ERP FROM TMPIMPORDEN";
                    DtConsulta = mod.consulta(StrConsulta);//FJRF - Consultamos los datos

                    #region FJRF - CargamosLosDatosQueSeVanAImprimir
                    if (DtConsulta.Rows.Count==0)//FJRF - Verificamos si existen datos de la consulta que se va a imprimir y si no hay datos hacemos lo siguiente
                    {
                        Msgbox("PROCESO CANCELADO", "No existen datos para imprimir el reporte", MessageBoxButton.OK, MessageBoxImage.Error); //FJRF - Informamos al usuario
                        return;//FJRF - Nos salimos
                    }
                    else//FJRF - Si hay datos hacemos lo siguiente
                    {
                        String StrNumeroOrdenEntrega = "";//FJRF - Para el manejo de las entregas
                        for (int IntFilaActual = 0; IntFilaActual < DtConsulta.Rows.Count; IntFilaActual++)//FJRF - Recorremos la informacion encontrada
                        {
                            StrNumeroOrdenEntrega = DtConsulta.Rows[IntFilaActual][0].ToString();//FJRF - Extraemos la entrega
                            if (String.IsNullOrEmpty(StrNumeroOrdenEntrega) == false)
                            {
                                DtConsulta.Rows[IntFilaActual][0] = "*" + StrNumeroOrdenEntrega + "*";
                            }
                        }

                        DtImprimir = new DataTable("DtDatosReporte");
                        DtImprimir = DtConsulta.Copy();//FJRF - Hacemos una copia de los datos
                        DtImprimir.TableName = "DtDatosReporte";//FJRF - Renombramos la tabla

                        #region FJRF - ImprimimosElReporte
                        DsImprimir = new DataSet("dsImpresoraDymoImprimirOrden");//FJRF - DataSet que esta vinculado al CrystalReport

                        //FJRF - ADICIONAMOS LAS TABLAS QUE NECESITE EL DATASET ASOCIADO AL CRYSTAL
                        DsImprimir.Tables.Add(DtImprimir.Copy());//Detalle del Informe

                        produccion.reportes.Vista vista = new produccion.reportes.Vista { ds = DsImprimir, reporte = StrRutaReporteAImprimir };//FJRF - Enviamos los datos para que se imprima el reporte
                        vista.Show();//FJRF - Ejecutamos el reporte para que se muestre visualmente

                        #endregion
                    }
                    #endregion
                }
                else//FJRF - Si el reporte no existe hacemos lo siguiente
                {
                    Msgbox("PROCESO CANCELADO", "El reporte no existe en la ruta: [" + StrRutaReporteAImprimir + "] por favor comuniquese con el administrador del sistema para que corriga este inconveniente.", MessageBoxButton.OK, MessageBoxImage.Error);//FJRF - Enviamos un mensaje al usuario
                }
            }
            catch (Exception ex)//FJRF - Si se presenta algun error hacemos lo siguiente
            {
                Msgbox("PROCESO CANCELADO - [Error del sistema]", ex.Message.ToString(), MessageBoxButton.OK, MessageBoxImage.Error);//FJRF - Enviamos un mensaje al usuario
            }
        }

        #region FJRF - CajaDeTextoMsgbox
        protected void Msgbox(String StrCaption, String StrMensaje, MessageBoxButton MsbTipoBoton, MessageBoxImage MsbTipoImagenIcono)
        {
            MessageBoxButton buttons;
            buttons = MsbTipoBoton;

            MessageBoxImage icon = MsbTipoImagenIcono;
            MessageBox.Show(StrMensaje, StrCaption, buttons, icon);
        }
        #endregion

        void limpiar()
        {
            try
            {
                strCodigoCliente = null;
                strNombreCliente = null;
                strReparacion = null;
                strDocumento = null;
                //strNroDocumento = null;
                strControl = null;
                strTipoMov = null;
                strReferencia = null;
                strNombreReferencia = null;
                strColor = null;
                strNombreColor = null;
                strTalla = null;
                strObservacion = null;
                strMotivo1 = null;
                strMotivo2 = null;
                strMotivo3 = null;
                strMotivo4 = null;
                strMotivo5 = null;
                strCodigoDaño1 = null;
                strCodigoDaño2 = null;
                strCodigoDaño3 = null;
                strCodigoDaño4 = null;
                strCodigoDaño5 = null;
                strDaño1 = null;
                strDaño2 = null;
                strDaño3 = null;
                strDaño4 = null;
                strDaño5 = null;
                strCodigoSolucion1 = null;
                strCodigoSolucion2 = null;
                strCodigoSolucion3 = null;
                strCodigoSolucion4 = null;
                strCodigoSolucion5 = null;
                strSolucion1 = null;
                strSolucion2 = null;
                strSolucion3 = null;
                strSolucion4 = null;
                strSolucion5 = null;
                strObservacionesEnc = null;
                strTipoSolucion = null;
                strProcesoInicial = null;
                if (visorFotoReferencia != null)
                {
                    if (visorFotoReferencia.strCodigo != null)
                        visorFotoReferencia.strCodigo = "";
                }
                dtmFecha = DateTime.Now;
                selpieza = null;
                selresponsable = null;
                selcausa = null;
                selsolucion = null;
                seldesicion = null;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        void imprimirOrden(string strNumeroOrden)
        {
            try
            {
                CLSENCORDP encOrden = new CLSENCORDP();
                CLSDETORDP detOrden = new CLSDETORDP();
                CLSMAEPRO maeProducto = new CLSMAEPRO();
                CLSENCPRCP encProceso = new CLSENCPRCP();

                DataTable dtEncabezado = new DataTable("dtEncabezado");
                DataRow drEncabezado = dtEncabezado.NewRow();

                DataTable dtEncabezadoTallas;
                DataRow drEncabezadoTallas;

                DataTable dtDetalleTallas;
                DataRow drDetalleTallas;

                DataTable dtTotalTallas;
                DataRow drtotalTallas;

                DataTable dtOrd = new DataTable();
                DataTable dtDetalle = new DataTable();

                string strMot = "";
                string strSol="";

                if (strDaño1 != null)
                {
                    if (!String.IsNullOrEmpty(strDaño1))
                        strMot = strMot + strDaño1.Trim();
                }
                if (strDaño2 != null)
                {
                    if (!String.IsNullOrEmpty(strDaño2))
                        strMot = strMot + ", " + strDaño2.Trim();
                }
                if (strDaño3 != null)
                {
                    if (!String.IsNullOrEmpty(strDaño3))
                        strMot = strMot + ", " + strDaño3.Trim();
                }
                if (strDaño4 != null)
                {
                    if (!String.IsNullOrEmpty(strDaño4))
                        strMot = strMot + ", " + strDaño4.Trim();
                }
                if (strDaño5 != null)
                {
                    if (!String.IsNullOrEmpty(strDaño5))
                        strMot = strMot + ", " + strDaño5.Trim();
                }

                if (strSolucion1 != null)
                {
                    if (!String.IsNullOrEmpty(strSolucion1))
                        strSol = strSol + strMotivo1.Trim();
                }
                if (strSolucion2 != null)
                {
                    if (!String.IsNullOrEmpty(strSolucion2))
                        strSol = strSol + ", " + strSolucion2.Trim();
                }
                if (strSolucion3 != null)
                {
                    if (!String.IsNullOrEmpty(strSolucion3))
                        strSol = strSol + ", " + strSolucion3.Trim();
                }
                if (strSolucion4 != null)
                {
                    if (!String.IsNullOrEmpty(strSolucion4))
                        strSol = strSol + ", " + strSolucion4.Trim();
                }
                if (strSolucion5 != null)
                {
                    if (!String.IsNullOrEmpty(strSolucion5))
                        strSol = strSol + ", " + strSolucion5.Trim();
                }


                dtEncabezado.Columns.Add("strCliente");
                dtEncabezado.Columns.Add("strNombreCliente");
                dtEncabezado.Columns.Add("strReferencia");
                dtEncabezado.Columns.Add("strNombreReferencia");
                dtEncabezado.Columns.Add("strColor");
                dtEncabezado.Columns.Add("strNombreColor");
                dtEncabezado.Columns.Add("strOrden");
                dtEncabezado.Columns.Add("strPedido");
                dtEncabezado.Columns.Add("strFecha");
                dtEncabezado.Columns.Add("strMotivos");
                dtEncabezado.Columns.Add("strSoluciones");
                dtEncabezado.Columns.Add("strProceso");
                dtEncabezado.Columns.Add("strTipo");
                dtEncabezado.Columns.Add("strEmpresa");

                drEncabezado["strCliente"] = strCodigoCliente;
                drEncabezado["strNombreCliente"] = strNombreCliente;
                drEncabezado["strReferencia"] = strReferencia;
                drEncabezado["strNombreReferencia"] = strNombreReferencia;
                drEncabezado["strColor"] = strColor;
                drEncabezado["strNombreColor"] = strNombreColor;
                drEncabezado["strOrden"] = strOrden;
                drEncabezado["strPedido"] = Convert.ToString(DateTime.Now.Year);
                drEncabezado["strFecha"] = dtmFecha.ToString("dd/MM/yyyy");
                drEncabezado["strMotivos"] = strMot;
                drEncabezado["strSoluciones"] = strSol;
                drEncabezado["strProceso"] = strProcesoInicial == "G" ? "GUARNECIDA" : strProcesoInicial == "M" ? "MONTAJE" : "DESPACHO"; 
                drEncabezado["strTipo"] = strTipoSolucion == "G" ? "GARANTIA" : strTipoSolucion == "S" ? "SERVICIO" : strTipoSolucion == "C" ? "RECONOCIDO" : strTipoSolucion == "D" ? "DEVOLUCION" : "REPARACION";
                drEncabezado["STREMPRESA"] = MDOgeneral.strEmpresaImprime;
                dtEncabezado.Rows.Add(drEncabezado);

                dtOrd.Clear();
                dtOrd.Columns.Add(new DataColumn("Seccion-Pedido", System.Type.GetType("System.String")));
                DataRow dr = dtOrd.NewRow();

                dr[0] = "Por programar";
                dtOrd.Rows.Add(dr);
                dr = dtOrd.NewRow();
                dr[0] = "Cantidad";
                dtOrd.Rows.Add(dr);
                dr = dtOrd.NewRow();
                dr[0] = "Programación";
                dtOrd.Rows.Add(dr);
                dr = dtOrd.NewRow();
                dr[0] = "Preparacion"; 
                dtOrd.Rows.Add(dr);
                dr = dtOrd.NewRow();
                dr[0] = "Corte";
                dtOrd.Rows.Add(dr);
                dr = dtOrd.NewRow();
                dr[0] = "Guarnecida";
                dtOrd.Rows.Add(dr);
                dr = dtOrd.NewRow();
                dr[0] = "Montaje";
                dtOrd.Rows.Add(dr);
                dr = dtOrd.NewRow();
                dr[0] = "Despachos";
                dtOrd.Rows.Add(dr);

                encOrden.NROORD_EOP = strNumeroOrden;
                encOrden.consultar();

                if (encOrden.EXISTE)
                {
                    maeProducto.CODREF_PRO = strReferencia;
                    maeProducto.CODCOL_PRO = strColor;
                    DataTable dt = maeProducto.BuscarTallas();

                    dtEncabezadoTallas = new DataTable("dtEncabezadoTallas");
                    dtEncabezadoTallas.Columns.Add("0", System.Type.GetType("System.String"));
                    dtEncabezadoTallas.Columns.Add("1", System.Type.GetType("System.String"));
                    dtEncabezadoTallas.Columns.Add("2", System.Type.GetType("System.String"));
                    dtEncabezadoTallas.Columns.Add("3", System.Type.GetType("System.String"));
                    dtEncabezadoTallas.Columns.Add("4", System.Type.GetType("System.String"));
                    dtEncabezadoTallas.Columns.Add("5", System.Type.GetType("System.String"));
                    dtEncabezadoTallas.Columns.Add("6", System.Type.GetType("System.String"));
                    dtEncabezadoTallas.Columns.Add("7", System.Type.GetType("System.String"));
                    dtEncabezadoTallas.Columns.Add("8", System.Type.GetType("System.String"));
                    dtEncabezadoTallas.Columns.Add("9", System.Type.GetType("System.String"));
                    dtEncabezadoTallas.Columns.Add("10", System.Type.GetType("System.String"));
                    dtEncabezadoTallas.Columns.Add("11", System.Type.GetType("System.String"));
                    drEncabezadoTallas = dtEncabezadoTallas.NewRow();

                    int IntTotalTallas = 0;
                    int IntCantidadTallas = 0;

                    dtTotalTallas = new DataTable("dtTotalTallas");
                    dtTotalTallas.Columns.Add("CantidadTallas", System.Type.GetType("System.String"));
                    dtTotalTallas.Columns.Add("TotalTallas", System.Type.GetType("System.String"));
                    drtotalTallas = dtTotalTallas.NewRow();

                    dtDetalleTallas = new DataTable("dtDetalleTalla");
                    dtDetalleTallas.Columns.Add("A0", System.Type.GetType("System.String"));
                    dtDetalleTallas.Columns.Add("A1", System.Type.GetType("System.String"));
                    dtDetalleTallas.Columns.Add("A2", System.Type.GetType("System.String"));
                    dtDetalleTallas.Columns.Add("A3", System.Type.GetType("System.String"));
                    dtDetalleTallas.Columns.Add("A4", System.Type.GetType("System.String"));
                    dtDetalleTallas.Columns.Add("A5", System.Type.GetType("System.String"));
                    dtDetalleTallas.Columns.Add("A6", System.Type.GetType("System.String"));
                    dtDetalleTallas.Columns.Add("A7", System.Type.GetType("System.String"));
                    dtDetalleTallas.Columns.Add("A8", System.Type.GetType("System.String"));
                    dtDetalleTallas.Columns.Add("A9", System.Type.GetType("System.String"));
                    dtDetalleTallas.Columns.Add("A10", System.Type.GetType("System.String"));
                    dtDetalleTallas.Columns.Add("A11", System.Type.GetType("System.String"));
                    drDetalleTallas = dtDetalleTallas.NewRow();

                    for (int j = 1; j < dt.Rows.Count; j++)
                    {
                        dtOrd.Columns.Add(new DataColumn(dt.Rows[j - 1][0].ToString(), System.Type.GetType("System.Double")));
                        drEncabezadoTallas[j - 1] = dt.Rows[j - 1][0].ToString();
                        IntCantidadTallas = IntCantidadTallas + 1;
                    }

                    detOrden.NROORD_DOP = strNumeroOrden;
                    detOrden.CODREF_DOP = strReferencia;
                    detOrden.CODCOL_DOP = strColor;
                    encProceso.NROORD_EPP = strNumeroOrden;
                    dtDetalle = encProceso.consCatPro();

                    for (int j = 1; j < dtOrd.Columns.Count; j++)
                    {
                        detOrden.CODTAL_DOP = dtOrd.Columns[j].Caption;
                        if (detOrden.existe())
                        {
                            detOrden.consultar();
                            dtOrd.Rows[0][j] = (detOrden.CANORD_DOP - detOrden.CANPRG_DOP);
                            dtOrd.Rows[2][j] = detOrden.CANPRG_DOP;

                            drDetalleTallas[j - 1] = detOrden.CANPRG_DOP;//FJRF - Cargamos los datos en las columnas
                            IntTotalTallas = IntTotalTallas + detOrden.CANPRG_DOP;//FJRF - Sumamos las cantidades de las tallas

                            dtOrd.Rows[3][j] = detOrden.CANCOR_DOP;
                            dtOrd.Rows[4][j] = detOrden.CANPRP_DOP;
                            dtOrd.Rows[5][j] = detOrden.CANGUA_DOP;
                            dtOrd.Rows[6][j] = detOrden.CANMON_DOP;
                            dtOrd.Rows[7][j] = detOrden.CANDES_DOP;
                        }
                    }

                    drtotalTallas["CantidadTallas"] = IntCantidadTallas;
                    drtotalTallas["TotalTallas"] = IntTotalTallas;

                    dtEncabezadoTallas.Rows.Add(drEncabezadoTallas);
                    dtDetalleTallas.Rows.Add(drDetalleTallas);
                    dtTotalTallas.Rows.Add(drtotalTallas);

                    DataSet ds = new DataSet("dsOrdenGarantias");

                    ds.Tables.Add(dtEncabezadoTallas);
                    ds.Tables.Add(dtDetalleTallas);
                    ds.Tables.Add(dtTotalTallas);
                    ds.Tables.Add(dtEncabezado);

                    produccion.reportes.Vista vista = new produccion.reportes.Vista { ds = ds, reporte = @"reportes\rptOrdenGarantias.rpt" };

                    vista.Show();
                }

            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public void Salir(Object frmformulario)
        {
            ((Window)frmformulario).Close();
        }

        void guardarDocumento()
        {
            try
            {
                if (strEmpresa == null)
                {
                    MessageBox.Show("Debe seleccionar una empresa.", "Seleccione empresa", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK);
                }
                else
                {

                    if (strEmpresa == "B")
                    {
                        Mouse.OverrideCursor = Cursors.Wait;

                        MDOgeneral.ConectarBogota();

                        MDOgeneral.spComandoBogota.CommandText = "SP_CARGARREPPENFBR";
                        MDOgeneral.spComandoBogota.Connection = MDOgeneral.ConexionBogota;
                        MDOgeneral.spComandoBogota.CommandType = CommandType.StoredProcedure;
                        MDOgeneral.spComandoBogota.Parameters.Clear();

                        //Input
                        MDOgeneral.spComandoBogota.Parameters.Add("pva_nrodoc", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strNroDocumento;
                        MDOgeneral.spComandoBogota.Parameters["pva_nrodoc"].Direction = ParameterDirection.Input;

                        //Output
                        MDOgeneral.spComandoBogota.Parameters.Add("pva_result", Oracle.DataAccess.Client.OracleDbType.Varchar2, 2000).Direction = ParameterDirection.Output;
                        MDOgeneral.spComandoBogota.Parameters.Add("pva_errusu", Oracle.DataAccess.Client.OracleDbType.Varchar2, 2000).Direction = ParameterDirection.Output;
                        MDOgeneral.spComandoBogota.ExecuteNonQuery();

                        if (MDOgeneral.spComandoBogota.Parameters["pva_result"].Value.ToString() == "N")
                        {
                            MessageBox.Show("No se encontro el documento: " + strNroDocumento + " en Baldini.", "Inconsistencia en el numero del Documento", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK);
                        }
                        if (MDOgeneral.spComandoBogota.Parameters["pva_result"].Value.ToString() == "X")
                        {
                            MessageBox.Show("El documento: " + strNroDocumento + " ya fue grabado. Vericar", "Inconsistencia en el numero del Documento", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK);
                        }
                        if (MDOgeneral.spComandoBogota.Parameters["pva_result"].Value.ToString() == "S")
                        {
                            if (selcliente.CODCLI_CLI != null)
                                consultarReparaciones(selcliente.CODCLI_CLI);
                            else
                                consultarReparaciones("ZZZ");
                        }

                        Mouse.OverrideCursor = Cursors.Arrow;
                    }
                    else
                    {
                        Mouse.OverrideCursor = Cursors.Wait;

                        MDOgeneral.conectar();

                        MDOgeneral.spComando.CommandText = "SP_CARGARREPPENENARTESA";
                        MDOgeneral.spComando.Connection = MDOgeneral.conexion;
                        MDOgeneral.spComando.CommandType = CommandType.StoredProcedure;
                        MDOgeneral.spComando.Parameters.Clear();

                        //Input
                        MDOgeneral.spComando.Parameters.Add("pva_nrodoc", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strNroDocumento;
                        MDOgeneral.spComando.Parameters["pva_nrodoc"].Direction = ParameterDirection.Input;

                        //Output
                        MDOgeneral.spComando.Parameters.Add("pva_result", Oracle.DataAccess.Client.OracleDbType.Varchar2, 2000).Direction = ParameterDirection.Output;
                        MDOgeneral.spComando.Parameters.Add("pva_errusu", Oracle.DataAccess.Client.OracleDbType.Varchar2, 2000).Direction = ParameterDirection.Output;
                        MDOgeneral.spComando.ExecuteNonQuery();

                        if (MDOgeneral.spComando.Parameters["pva_errusu"].Value.ToString() == "N")
                        {
                            MessageBox.Show("No se encontro el documento: " + strNroDocumento + " en Alcantara.", "Inconsistencia en el numero del Documento", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK);
                        }
                        if (MDOgeneral.spComando.Parameters["pva_result"].Value.ToString() == "X")
                        {
                            MessageBox.Show("El documento: " + strNroDocumento + " ya fue grabado. Vericar", "Inconsistencia en el numero del Documento", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK);
                        }
                        if (MDOgeneral.spComando.Parameters["pva_errusu"].Value.ToString() == "S")
                        {
                            if (selcliente.CODCLI_CLI != null)
                                consultarReparaciones(selcliente.CODCLI_CLI);
                            else
                                consultarReparaciones("ZZZ");
                        }

                        Mouse.OverrideCursor = Cursors.Arrow;
                    }
                    IsOpenHabilitarDoc = false;
                }                
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public void SalirDoc()
        {
            IsOpenHabilitarDoc = false;
        }

        public void SalirMensaje()
        {
            IsOpenMensaje = false;
            dtDocumento.Clear();
        }

        public void SalirIngresoManual()
        {
            IsOpenIngresoManual = false;
        }

        void copiarvariables()
        {
            try
            {
                logPegar = true;

                strDaño1C = strDaño1;
                strDaño2C = strDaño2;
                strDaño3C = strDaño3;
                strDaño4C = strDaño4;
                strDaño5C = strDaño5;

                strCodigoDaño1C = strCodigoDaño1;
                strCodigoDaño2C = strCodigoDaño2;
                strCodigoDaño3C = strCodigoDaño3;
                strCodigoDaño4C = strCodigoDaño4;
                strCodigoDaño5C = strCodigoDaño5;

                strSolucion1C = strSolucion1;
                strSolucion2C = strSolucion2;
                strSolucion3C = strSolucion3;
                strSolucion4C = strSolucion4;
                strSolucion5C = strSolucion5;

                strCodigoSolucion1C = strCodigoSolucion1;
                strCodigoSolucion2C = strCodigoSolucion2;
                strCodigoSolucion3C = strCodigoSolucion3;
                strCodigoSolucion4C = strCodigoSolucion4;
                strCodigoSolucion5C = strCodigoSolucion5;

                strOrdenC = strOrden;
                strObservacionesEncC = strObservacionesEnc;
                strTipoSolucionC = strTipoSolucion;
                strProcesoInicialC = strProcesoInicial;

                selpiezaC = selpieza;
                selresponsableC = selresponsable;
                selcausaC = selcausa;
                selsolucionC = selsolucion;
                seldesicionC = seldesicion;

            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        void pegarvariables()
        {
            try
            {
                strCodigoDaño1 = strCodigoDaño1C;
                strCodigoDaño2 = strCodigoDaño2C;
                strCodigoDaño3 = strCodigoDaño3C;
                strCodigoDaño4 = strCodigoDaño4C;
                strCodigoDaño5 = strCodigoDaño5C;

                strCodigoSolucion1 = strCodigoSolucion1C;
                strCodigoSolucion2 = strCodigoSolucion2C;
                strCodigoSolucion3 = strCodigoSolucion3C;
                strCodigoSolucion4 = strCodigoSolucion4C;
                strCodigoSolucion5 = strCodigoSolucion5C;

                strDaño1 = strDaño1C;
                strDaño2 = strDaño2C;
                strDaño3 = strDaño3C;
                strDaño4 = strDaño4C;
                strDaño5 = strDaño5C;                

                strSolucion1 = strSolucion1C;
                strSolucion2 = strSolucion2C;
                strSolucion3 = strSolucion3C;
                strSolucion4 = strSolucion4C;
                strSolucion5 = strSolucion5C;                

                strOrden = strOrdenC;
                strObservacionesEnc = strObservacionesEncC;
                strTipoSolucion = strTipoSolucionC;
                strProcesoInicial = strProcesoInicialC;

                selpieza = selpiezaC;
                selresponsable = selresponsableC;
                selcausa = selcausaC;
                selsolucion = selsolucionC;
                seldesicion = seldesicionC;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        #endregion

        
        #region IDataErrorInfo Members

        string IDataErrorInfo.Error { get { return null; } }

        string IDataErrorInfo.this[string propertyName]
        {
            get { return this.GetValidationError(propertyName); }
        }

        #endregion

        #region Validation

        /// <summary>
        /// Returns true if this object has no validation errors.
        /// </summary>
        /// 

        public bool IsValid
        {
            get
            {
                foreach (string property in ValidatedProperties)
                    if (GetValidationError(property) != null)
                        return false;

                return true;
            }
        }

        static readonly string[] ValidatedProperties = 
                    { 
                        "strDaño1",
                        "strSolucion1",
                        "strDaño2",
                        "strSolucion2",
                        "strDaño3",
                        "strSolucion3",
                        "strDaño4",
                        "strSolucion4",
                        "strDaño5",
                        "strSolucion5",
                        "strTipoSolucion",
                        "strProcesoInicial",
                    };

        string GetValidationError(string propertyName)
        {
            string error = null;

            if (Array.IndexOf(ValidatedProperties, propertyName) < 0)
                return null;

            //&& CODCPT_NVP.Length==3
            switch (propertyName)
            {
                case "strDaño1":
                    error = this.ValidateDaño1();
                    break;
                case "strSolucion1":
                    error = this.ValidateSolucion1();
                    break;
                case "strDaño2":
                    error = this.ValidateDaño2();
                    break;
                case "strSolucion2":
                    error = this.ValidateSolucion2();
                    break;
                case "strDaño3":
                    error = this.ValidateDaño3();
                    break;
                case "strSolucion3":
                    error = this.ValidateSolucion3();
                    break;
                case "strDaño4":
                    error = this.ValidateDaño4();
                    break;
                case "strSolucion4":
                    error = this.ValidateSolucion4();
                    break;
                case "strDaño5":
                    error = this.ValidateDaño5();
                    break;
                case "strSolucion5":
                    error = this.ValidateSolucion5();
                    break;
                case "strTipoSolucion":
                    error = this.ValidateTipo();
                    break;
                case "strProcesoInicial":
                    error = this.ValidateProcesoInicial();
                    break;
                default:
                    Debug.Fail("Unexpected property being validated on Customer: " + propertyName);
                    break;
            }
            return error;
        }

        string ValidateDaño1()
        {
            try
            {
                if (strDaño1 != null)
                {
                    if (strCodigoDaño1 != null)
                    {
                        if (strCodigoDaño1.Length < 2)
                            return "Daño no existe Buscarlo con [F2].";
                    }
                    else
                        return "Debe ingresar un Daño consultandolo con [F2].";
                }
                else
                    return "Debe ingresar un Daño.";
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        string ValidateSolucion1()
        {
            try
            {
                if (strSolucion1 != null)
                {
                    if (strCodigoSolucion1 != null)
                    {
                        if (strCodigoSolucion1.Length < 3)
                            return "Solución no existe Buscarla con [F2].";
                    }
                    else
                        return "Debe ingresar una solucion consultandola con [F2].";
                }
                else
                    return "Debe ingresar una Solución.";
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        string ValidateDaño2()
        {
            try
            {
                if (strDaño2 != null)
                {
                    if (strCodigoDaño2 != null)
                    {
                        if (strCodigoDaño2.Length < 2)
                            return "Daño no existe Buscarlo con [F2].";
                    }
                    else
                    {
                        if (String.IsNullOrEmpty(strDaño2))
                            return null;
                        else
                            return "Debe ingresar un Daño consultandolo con [F2].";
                    }

                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        string ValidateSolucion2()
        {
            try
            {
                if (strSolucion2 != null)
                {
                    if (strCodigoSolucion2 != null)
                    {
                        if (strCodigoSolucion2.Length < 3)
                            return "Solución no existe Buscarla con [F2].";
                    }
                    else
                    {
                        if (String.IsNullOrEmpty(strSolucion2))
                            return null;
                        else
                            return "Debe ingresar una Solución consultandola con [F2].";
                    }
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        string ValidateDaño3()
        {
            try
            {
                if (strDaño3 != null)
                {
                    if (strCodigoDaño3 != null)
                    {
                        if (strCodigoDaño3.Length < 2)
                            return "Daño no existe Buscarlo con [F2].";
                    }
                    else
                    {
                        if (String.IsNullOrEmpty(strDaño3))
                            return null;
                        else
                            return "Debe ingresar un Daño consultandolo con [F2].";
                    }
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        string ValidateSolucion3()
        {
            try
            {
                if (strSolucion3 != null)
                {
                    if (strCodigoSolucion3 != null)
                    {
                        if (strCodigoSolucion3.Length < 3)
                            return "Solución no existe Buscarla con [F2].";
                    }
                    else
                    {
                        if (String.IsNullOrEmpty(strSolucion3))
                            return null;
                        else
                            return "Debe ingresar una Solución consultandola con [F2].";
                    }
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        string ValidateDaño4()
        {
            try
            {
                if (strDaño4 != null)
                {
                    if (strCodigoDaño4 != null)
                    {
                        if (strCodigoDaño4.Length < 2)
                            return "Daño no existe Buscarlo con [F2].";
                    }
                    else
                    {
                        if (String.IsNullOrEmpty(strDaño4))
                            return null;
                        else
                            return "Debe ingresar un Daño consultandolo con [F2].";
                    }
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        string ValidateSolucion4()
        {
            try
            {
                if (strSolucion4 != null)
                {
                    if (strCodigoSolucion4 != null)
                    {
                        if (strCodigoSolucion4.Length < 3)
                            return "Solución no existe Buscarla con [F2].";
                    }
                    else
                    {
                        if (String.IsNullOrEmpty(strSolucion4))
                            return null;
                        else
                            return "Debe ingresar una Solución consultandola con [F2].";
                    }
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }
        string ValidateDaño5()
        {
            try
            {
                if (strDaño5 != null)
                {
                    if (strCodigoDaño5 != null)
                    {
                        if (strCodigoDaño5.Length < 2)
                            return "Daño no existe Buscarlo con [F2].";
                    }
                    else
                    {
                        if (String.IsNullOrEmpty(strDaño5))
                            return null;
                        else
                            return "Debe ingresar un Daño consultandolo con [F2].";
                    }
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        string ValidateSolucion5()
        {
            try
            {
                if (strSolucion5 != null)
                {
                    if (strCodigoSolucion5 != null)
                    {
                        if (strCodigoSolucion5.Length < 3)
                            return "Solución no existe Buscarla con [F2].";
                    }
                    else
                    {
                        if (String.IsNullOrEmpty(strSolucion5))
                            return null;
                        else
                            return "Debe ingresar una Solución consultandola con [F2].";
                    }
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        string ValidateTipo()
        {
            try
            {
                if (strTipoSolucion != null)
                {
                    if (strTipoSolucion.Length < 1)
                            return "Debe seleccionar algun tipo de solución.";

                }
                else
                    return "Debe Escoger un Tipo de Solución.";
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        string ValidateProcesoInicial()
        {
            try
            {
                if (strProcesoInicial != null)
                {
                    if (strProcesoInicial.Length < 1)
                        return "Debe seleccionar algun proceso inicial.";

                }
                else
                    return "Debe Escoger un Proceso Inicial.";
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        #endregion

    }

    #region Vista-modelo
    public class VMProcesarGarSerRec : ViewModelBase
    {

        #region Campos
        private MGarantiasServiciosyReconocidos _procesos = new MGarantiasServiciosyReconocidos();
        #endregion

        #region Constructor

        public VMProcesarGarSerRec(MGarantiasServiciosyReconocidos procesos)
        {
            _procesos = procesos;
        }

        #endregion

        #region Propiedades

        public string strCodigoCliente
        {
            get { return _procesos.strCodigoCliente; }
            set { _procesos.strCodigoCliente = value; base.OnPropertyChanged("strCodigoCliente"); }
        }

        public string strNombreCliente
        {
            get { return _procesos.strNombreCliente; }
            set { _procesos.strNombreCliente = value; base.OnPropertyChanged("strNombreCliente"); }
        }

        public string strTipo
        {
            get { return _procesos.strTipo; }
            set { _procesos.strTipo = value; base.OnPropertyChanged("strTipo"); }
        }

        public string strDocumento
        {
            get { return _procesos.strDocumento; }
            set { _procesos.strDocumento = value; base.OnPropertyChanged("strDocumento"); }
        }

        public string strReparacion
        {
            get { return _procesos.strReparacion; }
            set { _procesos.strReparacion = value; base.OnPropertyChanged("strReparacion"); }
        }

        public string strControl
        {
            get { return _procesos.strControl; }
            set { _procesos.strControl = value; base.OnPropertyChanged("strControl"); }
        }

        public string strReferencia
        {
            get { return _procesos.strReferencia; }
            set { _procesos.strReferencia = value; base.OnPropertyChanged("strReferencia"); }
        }

        public string strNombreReferencia
        {
            get { return _procesos.strNombreReferencia; }
            set { _procesos.strNombreReferencia = value; base.OnPropertyChanged("strNombreReferencia"); }
        }

        public string strColor
        {
            get { return _procesos.strColor; }
            set { _procesos.strColor = value; base.OnPropertyChanged("strColor"); }
        }

        public string strNombreColor
        {
            get { return _procesos.strNombreColor; }
            set { _procesos.strNombreColor = value; base.OnPropertyChanged("strNombreColor"); }
        }

        public string strTalla
        {
            get { return _procesos.strTalla; }
            set { _procesos.strTalla = value; base.OnPropertyChanged("strTalla"); }
        }

        public string strMotivo1
        {
            get { return _procesos.strMotivo1; }
            set { _procesos.strMotivo1 = value; base.OnPropertyChanged("strMotivo1"); }
        }

        public string strMotivo2
        {
            get { return _procesos.strMotivo2; }
            set { _procesos.strMotivo2 = value; base.OnPropertyChanged("strMotivo2"); }
        }

        public string strMotivo3
        {
            get { return _procesos.strMotivo3; }
            set { _procesos.strMotivo3 = value; base.OnPropertyChanged("strMotivo3"); }
        }

        public string strMotivo4
        {
            get { return _procesos.strMotivo4; }
            set { _procesos.strMotivo4 = value; base.OnPropertyChanged("strMotivo4"); }
        }

        public string strMotivo5
        {
            get { return _procesos.strMotivo5; }
            set { _procesos.strMotivo5 = value; base.OnPropertyChanged("strMotivo5"); }
        }

        public string strObservacion
        {
            get { return _procesos.strObservacion; }
            set { _procesos.strObservacion = value; base.OnPropertyChanged("strObservacion"); }
        }

        #endregion

        #region Metodos

        public MGarantiasServiciosyReconocidos getProcesos()
        {
            return _procesos;
        }

        #endregion

    }
    #endregion
}
